package Job;
public class JobScheduling {

    public static void main(String[] args) {
        Job jobA = new Job("A", 0, 6);
        Job jobB = new Job("B", 2, 50);
        Job jobC = new Job("C", 5, 20);
        Job jobD = new Job("D", 5, 10);
        Job jobE = new Job("E", 12, 40);
        Job jobF = new Job("F", 15, 8);
        Job job[] = { jobA, jobB, jobC, jobD, jobE, jobF };
        // 先用冒泡排序，将它们按到达时间排序
        Bubble(job);
        // 先来先服务
        FCFS(job);
        // 短作业优先
        SJF(job);
        // 高响应者优先
        HRRN(job);
    }

    // 冒泡排序
    static void Bubble(Job job[]) {
        Job temp = new Job("", 0, 0); // 临时变量
        boolean flag = false; // 标识变量，表示是否进行过交换
        for (int i = 0; i < job.length - 1; i++) {
            for (int j = 0; j < job.length - 1 - i; j++) {
                // 如果前面的数比后面的数大，则交换
                if (job[j].arriveTime > job[j + 1].arriveTime) {
                    flag = true;
                    temp = job[j];
                    job[j] = job[j + 1];
                    job[j + 1] = temp;
                }
            }
            if (!flag) { // 在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false; // 重置flag, 进行下次判断
            }
        }
    }

    // 先来先服务算法
    static void FCFS(Job job[]) {
        double T = 0; // 平均周转时间
        double W = 0; // 平均带权周转时间
        int finish = 0; // 记录完成时间的变化
        double t = 0; // 周转时间
        double w = 0; // 带权周转时间

        System.out.println("先来先服务算法：");
        System.out.print("作业调度顺序：");
        for (int c = 0; c < job.length; c++) {
            // 记录完成时间的变化
            finish = finish + job[c].needTime;
            // 计算周转时间
            t = finish - job[c].arriveTime;
            // 计算带权周转时间
            w = t / job[c].needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(job[c].jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }

    // 短作业优先算法
    static void SJF(Job job[]) {
        int finish = job[0].needTime; // 记录完成时间的变化
        double t = finish - job[0].arriveTime; // 记录周转时间的变化
        double w = t / job[0].needTime; // 记录带权周转时间的变化
        double T = t; // 平均周转时间
        double W = w; // 平均带权周转时间

        int d = 0;// 记录当前选择到的作业号码
        int time = 100;// 记录服务时间的变化
        int arr[] = { 1, 0, 0, 0, 0, 0 }; // 记录作业的选择情况：1为选中，0为未选中

        System.out.println("短作业优先算法：");
        System.out.print("作业调度顺序：" + job[0].jobName);
        for (int e = 1; e < job.length; e++) {
            for (int c = 1; c < job.length; c++) {
                /**
                 * 需要判断：该作业在上一个作业完成时，是否已经到达 该作业是否已经执行完毕 该作业的服务时间是否为最小
                 * */
                if (job[c].arriveTime < finish && arr[c] == 0
                        && job[c].needTime < time) {
                    // 如果满足条件
                    d = c; // 暂时记录当前作业的下标
                    time = job[c].needTime; // 暂时记录该作业的服务时间为最小
                }
            }
            arr[d] = 1; // 作业已被调度，设置为1
            time = 100;// 重置
            // 记录完成时间的变化
            finish = finish + job[d].needTime;
            // 计算周转时间
            t = finish - job[d].arriveTime;
            // 计算带权周转时间
            w = t / job[d].needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(job[d].jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }

    // 响应比高者优先算法
    static void HRRN(Job job[]) {
        double finish = job[0].needTime; // 记录完成时间的变化
        double t = finish - job[0].arriveTime; // 记录周转时间的变化
        double w = t / job[0].needTime; // 记录带权周转时间的变化
        double T = t; // 平均周转时间
        double W = w; // 平均带权周转时间

        int d = 0;// 记录当前选择到的作业号码
        double time = 0;// 记录响应比
        int arr[] = { 1, 0, 0, 0, 0, 0 }; // 记录作业的选择情况：1为选中，0为未选中

        System.out.println("响应比高者优先算法：");
        System.out.print("作业调度顺序：" + job[0].jobName);
        for (int e = 1; e < job.length; e++) {
            for (int c = 1; c < job.length; c++) {
                // 响应比：(等待时间+要求服务)/要求服务
                double response = (finish - job[c].arriveTime + job[c].needTime)
                        / job[c].needTime;
                /**
                 * 需要判断：该作业在上一个作业完成时，是否已经到达 该作业是否已经执行完毕 该作业的响应比是否为最大
                 * */
                if (job[c].arriveTime < finish && response > time
                        && arr[c] == 0) {
                    d = c; // 暂时记录当前作业的下标
                    time = response; // 暂时记录该作业的服务时间为最大
                }
            }
            arr[d] = 1; // 作业已被调度，设置为1
            time = 0;// 重置
            // 记录完成时间的变化
            finish = finish + job[d].needTime;
            // 计算周转时间
            t = finish - job[d].arriveTime;
            // 计算带权周转时间
            w = t / job[d].needTime;
            // 记录周转时间总和
            T += t;
            // 记录带权周转时间总和
            W += w;
            System.out.print(job[d].jobName);
        }
        System.out.println();
        System.out.println("平均周转时间为：" + T / 6);
        System.out.println("平均带权周转时间为：" + W / 6);
        System.out.println("=========================");
    }
}

class Job {
    public String jobName; // 作业名
    public int arriveTime; // 到达时间
    public int needTime; // 服务时间

    // 构造器
    public Job(String jobName, int arriveTime, int needTime) {
        this.jobName = jobName;
        this.arriveTime = arriveTime;
        this.needTime = needTime;
    }

    @Override
    public String toString() {
        return "Job [jobName=" + jobName + ", arriveTime=" + arriveTime
                + ", needTime=" + needTime + "]";
    }

}
